package com.ourteam.workspace.dao;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;

/**
 * Template Name : DAO查询对象 Template Version : 1 Template Last Modfiy Date : Sat Aug 19 10:06:32 CST
 * 2017 Auto Generate Date : 2018-11-30 18:42:31 Warning ! This file will be overwrite when
 * regenerate !
 */
public class WorkspaceScmChangePathLogDAOQueryBean extends BaseQueryBean {

  public WorkspaceScmChangePathLogDAOQueryBean() {
    super();
  }

  public WorkspaceScmChangePathLogDAOQueryBean(BaseQueryBean aQueryBean) {
    super(aQueryBean);
  }

  public WorkspaceScmChangePathLogDAOQueryBean(BaseQueryBean aQueryBean, Map tableReplaceMap) {
    super(aQueryBean, tableReplaceMap);
  }

  public Criteria createCriteria() {

    Criteria criteria = createCriteriaInternal();
    if (oredCriteria.size() == 0) {
      oredCriteria.add(criteria);
    }
    return criteria;
  }

  protected Criteria createCriteriaInternal() {
    return new Criteria(this);
  }

  public void addIdSelectProperty() {
    addIdSelectProperty("id");
  }

  public void addIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Id, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Id, "id");
    }
  }

  public void addWorkspaceScmLogIdSelectProperty() {
    addWorkspaceScmLogIdSelectProperty("workspaceScmLogId");
  }

  public void addWorkspaceScmLogIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId, "workspaceScmLogId");
    }
  }

  public void addPathSelectProperty() {
    addPathSelectProperty("path");
  }

  public void addPathSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Path, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Path, "path");
    }
  }

  public void addActionSelectProperty() {
    addActionSelectProperty("action");
  }

  public void addActionSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Action, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Action, "action");
    }
  }

  public void addCopysrcrevisionSelectProperty() {
    addCopysrcrevisionSelectProperty("copysrcrevision");
  }

  public void addCopysrcrevisionSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Copysrcrevision, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Copysrcrevision, "copysrcrevision");
    }
  }

  public void addCopysrcpathSelectProperty() {
    addCopysrcpathSelectProperty("copysrcpath");
  }

  public void addCopysrcpathSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Copysrcpath, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Copysrcpath, "copysrcpath");
    }
  }

  public void addStatusSelectProperty() {
    addStatusSelectProperty("status");
  }

  public void addStatusSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Status, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Status, "status");
    }
  }

  public void addRemarksSelectProperty() {
    addRemarksSelectProperty("remarks");
  }

  public void addRemarksSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Remarks, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Remarks, "remarks");
    }
  }

  public void addWorkspaceIdSelectProperty() {
    addWorkspaceIdSelectProperty("workspaceId");
  }

  public void addWorkspaceIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.WorkspaceId, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.WorkspaceId, "workspaceId");
    }
  }

  public void addWorkspaceScmConfigIdSelectProperty() {
    addWorkspaceScmConfigIdSelectProperty("workspaceScmConfigId");
  }

  public void addWorkspaceScmConfigIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId, "workspaceScmConfigId");
    }
  }

  public void addChangeLineCountSelectProperty() {
    addChangeLineCountSelectProperty("changeLineCount");
  }

  public void addChangeLineCountSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.ChangeLineCount, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.ChangeLineCount, "changeLineCount");
    }
  }

  public void addLineCountSelectProperty() {
    addLineCountSelectProperty("lineCount");
  }

  public void addLineCountSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.LineCount, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.LineCount, "lineCount");
    }
  }

  public void addCommentLineCountSelectProperty() {
    addCommentLineCountSelectProperty("commentLineCount");
  }

  public void addCommentLineCountSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.CommentLineCount, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.CommentLineCount, "commentLineCount");
    }
  }

  public void addBlankLineCountSelectProperty() {
    addBlankLineCountSelectProperty("blankLineCount");
  }

  public void addBlankLineCountSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.BlankLineCount, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.BlankLineCount, "blankLineCount");
    }
  }

  public void addFileSizeSelectProperty() {
    addFileSizeSelectProperty("fileSize");
  }

  public void addFileSizeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.FileSize, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.FileSize, "fileSize");
    }
  }

  public void addAuthorSelectProperty() {
    addAuthorSelectProperty("author");
  }

  public void addAuthorSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Author, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Author, "author");
    }
  }

  public void addRevisionTimeSelectProperty() {
    addRevisionTimeSelectProperty("revisionTime");
  }

  public void addRevisionTimeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.RevisionTime, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.RevisionTime, "revisionTime");
    }
  }

  public void addRevisionSelectProperty() {
    addRevisionSelectProperty("revision");
  }

  public void addRevisionSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Revision, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.Revision, "revision");
    }
  }

  public void addTotalLinesSelectProperty() {
    addTotalLinesSelectProperty("totalLines");
  }

  public void addTotalLinesSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.TotalLines, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.TotalLines, "totalLines");
    }
  }

  public void addTotalSizeSelectProperty() {
    addTotalSizeSelectProperty("totalSize");
  }

  public void addTotalSizeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.TotalSize, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.TotalSize, "totalSize");
    }
  }

  public void addWorkspaceNameSelectProperty() {
    addWorkspaceNameSelectProperty("workspaceName");
  }

  public void addWorkspaceNameSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.WorkspaceName, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmChangePathLogDAO.WorkspaceName, "workspaceName");
    }
  }

  public void addAllSelectProperties() {

    addIdSelectProperty();

    addWorkspaceScmLogIdSelectProperty();

    addPathSelectProperty();

    addActionSelectProperty();

    addCopysrcrevisionSelectProperty();

    addCopysrcpathSelectProperty();

    addStatusSelectProperty();

    addRemarksSelectProperty();

    addWorkspaceIdSelectProperty();

    addWorkspaceScmConfigIdSelectProperty();

    addChangeLineCountSelectProperty();

    addLineCountSelectProperty();

    addCommentLineCountSelectProperty();

    addBlankLineCountSelectProperty();

    addFileSizeSelectProperty();

    addAuthorSelectProperty();

    addRevisionTimeSelectProperty();

    addRevisionSelectProperty();

    addTotalLinesSelectProperty();

    addTotalSizeSelectProperty();

    addWorkspaceNameSelectProperty();
  }

  public static class Criteria extends BaseWhereCriterion<WorkspaceScmChangePathLogDAOQueryBean> {

    protected Criteria(WorkspaceScmChangePathLogDAOQueryBean aParentObject) {
      super(aParentObject);
    }

    public Criteria andIdIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " is null");
      return this;
    }

    public Criteria andIdIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " is not null");
      return this;
    }

    public Criteria andIdIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Id
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.Id
              + " <> ''");
      return this;
    }

    public Criteria andIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.Id
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Id
              + " = '')");
      return this;
    }

    public Criteria andIdEqualTo(long value) {
      return andIdEqualTo(Long.valueOf(value));
    }

    public Criteria andIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " = ", value, "id");
      return this;
    }

    public Criteria andIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Id);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotEqualTo(long value) {
      return andIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToOrIsNull(long value) {
      return andIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.Id
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Id
              + " <>",
          value,
          "id");
      return this;
    }

    public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Id);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThan(long value) {
      return andIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " >", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Id);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(long value) {
      return andIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " >=", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Id);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThan(long value) {
      return andIdLessThan(Long.valueOf(value));
    }

    public Criteria andIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " <", value, "id");
      return this;
    }

    public Criteria andIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Id);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(long value) {
      return andIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " <=", value, "id");
      return this;
    }

    public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Id);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdIn(long[] values) {
      if (values.length == 1) {
        return andIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Id + " in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Id + " not in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andWorkspaceScmLogIdIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " is null");
      return this;
    }

    public Criteria andWorkspaceScmLogIdIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " is not null");
      return this;
    }

    public Criteria andWorkspaceScmLogIdIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceScmLogIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceScmLogIdEqualTo(long value) {
      return andWorkspaceScmLogIdEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmLogIdEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " = ", value, "workspaceScmLogId");
      return this;
    }

    public Criteria andWorkspaceScmLogIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmLogIdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmLogIdNotEqualTo(long value) {
      return andWorkspaceScmLogIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmLogIdNotEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " <>", value, "workspaceScmLogId");
      return this;
    }

    public Criteria andWorkspaceScmLogIdNotEqualToOrIsNull(long value) {
      return andWorkspaceScmLogIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmLogIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId
              + " <>",
          value,
          "workspaceScmLogId");
      return this;
    }

    public Criteria andWorkspaceScmLogIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmLogIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmLogIdGreaterThan(long value) {
      return andWorkspaceScmLogIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmLogIdGreaterThan(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " >", value, "workspaceScmLogId");
      return this;
    }

    public Criteria andWorkspaceScmLogIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmLogIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmLogIdGreaterThanOrEqualTo(long value) {
      return andWorkspaceScmLogIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmLogIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " >=", value, "workspaceScmLogId");
      return this;
    }

    public Criteria andWorkspaceScmLogIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmLogIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmLogIdLessThan(long value) {
      return andWorkspaceScmLogIdLessThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmLogIdLessThan(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " <", value, "workspaceScmLogId");
      return this;
    }

    public Criteria andWorkspaceScmLogIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmLogIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmLogIdLessThanOrEqualTo(long value) {
      return andWorkspaceScmLogIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmLogIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " <=", value, "workspaceScmLogId");
      return this;
    }

    public Criteria andWorkspaceScmLogIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmLogIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmLogIdIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceScmLogIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " in", values, "workspaceScmLogId");
        return this;
      }
    }

    public Criteria andWorkspaceScmLogIdNotIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceScmLogIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " not in",
            values,
            "workspaceScmLogId");
        return this;
      }
    }

    public Criteria andWorkspaceScmLogIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andWorkspaceScmLogIdEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " in", values, "workspaceScmLogId");
        return this;
      }
    }

    public Criteria andWorkspaceScmLogIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andWorkspaceScmLogIdNotEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " not in",
            values,
            "workspaceScmLogId");
        return this;
      }
    }

    public Criteria andWorkspaceScmLogIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andWorkspaceScmLogIdEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " in",
            Arrays.asList(values),
            "workspaceScmLogId");
        return this;
      }
    }

    public Criteria andWorkspaceScmLogIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andWorkspaceScmLogIdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " not in",
            Arrays.asList(values),
            "workspaceScmLogId");
        return this;
      }
    }

    public Criteria andWorkspaceScmLogIdIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmLogIdNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmLogIdBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " between",
          value1,
          value2,
          "workspaceScmLogId");
      return this;
    }

    public Criteria andWorkspaceScmLogIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " between",
          value1,
          value2,
          "workspaceScmLogId");
      return this;
    }

    public Criteria andWorkspaceScmLogIdNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " not between",
          value1,
          value2,
          "workspaceScmLogId");
      return this;
    }

    public Criteria andWorkspaceScmLogIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmLogId + " not between",
          value1,
          value2,
          "workspaceScmLogId");
      return this;
    }

    public Criteria andPathIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " is null");
      return this;
    }

    public Criteria andPathIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " is not null");
      return this;
    }

    public Criteria andPathIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Path
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.Path
              + " <> ''");
      return this;
    }

    public Criteria andPathIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.Path
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Path
              + " = '')");
      return this;
    }

    public Criteria andPathEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " = ", value, "path");
      return this;
    }

    public Criteria andPathEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Path);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andPathEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andPathNotEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " <>", value, "path");
      return this;
    }

    public Criteria andPathNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.Path
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Path
              + " <>",
          value,
          "path");
      return this;
    }

    public Criteria andPathNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Path);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andPathNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andPathGreaterThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " >", value, "path");
      return this;
    }

    public Criteria andPathGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Path);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andPathGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andPathGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " >=", value, "path");
      return this;
    }

    public Criteria andPathGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Path);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andPathGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andPathLessThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " <", value, "path");
      return this;
    }

    public Criteria andPathLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Path);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andPathLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andPathLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " <=", value, "path");
      return this;
    }

    public Criteria andPathLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Path);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andPathLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andPathLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " like", buffer.toString(), "path");
      return this;
    }

    public Criteria andPathNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " not like", buffer.toString(), "path");
      return this;
    }

    public Criteria andPathIn(List<String> values) {

      if (values.size() == 1) {
        return andPathEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Path + " in", values, "path");
        return this;
      }
    }

    public Criteria andPathNotIn(List<String> values) {
      if (values.size() == 1) {
        return andPathNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Path + " not in", values, "path");
        return this;
      }
    }

    public Criteria andPathIn(String[] values) {

      if (values.length == 1) {
        return andPathEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Path + " in", Arrays.asList(values), "path");
        return this;
      }
    }

    public Criteria andPathNotIn(String[] values) {
      if (values.length == 1) {
        return andPathNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Path + " not in", Arrays.asList(values), "path");
        return this;
      }
    }

    public Criteria andPathIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andPathNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andPathBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " between", value1, value2, "path");
      return this;
    }

    public Criteria andPathNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Path + " not between", value1, value2, "path");
      return this;
    }

    public Criteria andActionIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " is null");
      return this;
    }

    public Criteria andActionIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " is not null");
      return this;
    }

    public Criteria andActionIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Action
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.Action
              + " <> ''");
      return this;
    }

    public Criteria andActionIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.Action
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Action
              + " = '')");
      return this;
    }

    public Criteria andActionEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " = ", value, "action");
      return this;
    }

    public Criteria andActionEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Action);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andActionEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andActionNotEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " <>", value, "action");
      return this;
    }

    public Criteria andActionNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.Action
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Action
              + " <>",
          value,
          "action");
      return this;
    }

    public Criteria andActionNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Action);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andActionNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andActionGreaterThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " >", value, "action");
      return this;
    }

    public Criteria andActionGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Action);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andActionGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andActionGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " >=", value, "action");
      return this;
    }

    public Criteria andActionGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Action);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andActionGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andActionLessThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " <", value, "action");
      return this;
    }

    public Criteria andActionLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Action);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andActionLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andActionLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " <=", value, "action");
      return this;
    }

    public Criteria andActionLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Action);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andActionLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andActionLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " like", buffer.toString(), "action");
      return this;
    }

    public Criteria andActionNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " not like", buffer.toString(), "action");
      return this;
    }

    public Criteria andActionIn(List<String> values) {

      if (values.size() == 1) {
        return andActionEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Action + " in", values, "action");
        return this;
      }
    }

    public Criteria andActionNotIn(List<String> values) {
      if (values.size() == 1) {
        return andActionNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Action + " not in", values, "action");
        return this;
      }
    }

    public Criteria andActionIn(String[] values) {

      if (values.length == 1) {
        return andActionEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Action + " in", Arrays.asList(values), "action");
        return this;
      }
    }

    public Criteria andActionNotIn(String[] values) {
      if (values.length == 1) {
        return andActionNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Action + " not in", Arrays.asList(values), "action");
        return this;
      }
    }

    public Criteria andActionIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andActionNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andActionBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " between", value1, value2, "action");
      return this;
    }

    public Criteria andActionNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Action + " not between", value1, value2, "action");
      return this;
    }

    public Criteria andCopysrcrevisionIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " is null");
      return this;
    }

    public Criteria andCopysrcrevisionIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " is not null");
      return this;
    }

    public Criteria andCopysrcrevisionIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcrevision
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.Copysrcrevision
              + " <> ''");
      return this;
    }

    public Criteria andCopysrcrevisionIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.Copysrcrevision
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Copysrcrevision
              + " = '')");
      return this;
    }

    public Criteria andCopysrcrevisionEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " = ", value, "copysrcrevision");
      return this;
    }

    public Criteria andCopysrcrevisionEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcrevision);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcrevisionEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcrevisionNotEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " <>", value, "copysrcrevision");
      return this;
    }

    public Criteria andCopysrcrevisionNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcrevision
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Copysrcrevision
              + " <>",
          value,
          "copysrcrevision");
      return this;
    }

    public Criteria andCopysrcrevisionNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcrevision);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcrevisionNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcrevisionGreaterThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " >", value, "copysrcrevision");
      return this;
    }

    public Criteria andCopysrcrevisionGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcrevision);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcrevisionGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcrevisionGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " >=", value, "copysrcrevision");
      return this;
    }

    public Criteria andCopysrcrevisionGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcrevision);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcrevisionGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcrevisionLessThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " <", value, "copysrcrevision");
      return this;
    }

    public Criteria andCopysrcrevisionLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcrevision);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcrevisionLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcrevisionLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " <=", value, "copysrcrevision");
      return this;
    }

    public Criteria andCopysrcrevisionLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcrevision);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcrevisionLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcrevisionLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcrevision + " like",
          buffer.toString(),
          "copysrcrevision");
      return this;
    }

    public Criteria andCopysrcrevisionNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcrevision + " not like",
          buffer.toString(),
          "copysrcrevision");
      return this;
    }

    public Criteria andCopysrcrevisionIn(List<String> values) {

      if (values.size() == 1) {
        return andCopysrcrevisionEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Copysrcrevision + " in", values, "copysrcrevision");
        return this;
      }
    }

    public Criteria andCopysrcrevisionNotIn(List<String> values) {
      if (values.size() == 1) {
        return andCopysrcrevisionNotEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Copysrcrevision + " not in", values, "copysrcrevision");
        return this;
      }
    }

    public Criteria andCopysrcrevisionIn(String[] values) {

      if (values.length == 1) {
        return andCopysrcrevisionEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Copysrcrevision + " in",
            Arrays.asList(values),
            "copysrcrevision");
        return this;
      }
    }

    public Criteria andCopysrcrevisionNotIn(String[] values) {
      if (values.length == 1) {
        return andCopysrcrevisionNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Copysrcrevision + " not in",
            Arrays.asList(values),
            "copysrcrevision");
        return this;
      }
    }

    public Criteria andCopysrcrevisionIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcrevisionNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcrevision + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcrevisionBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcrevision + " between",
          value1,
          value2,
          "copysrcrevision");
      return this;
    }

    public Criteria andCopysrcrevisionNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcrevision + " not between",
          value1,
          value2,
          "copysrcrevision");
      return this;
    }

    public Criteria andCopysrcpathIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " is null");
      return this;
    }

    public Criteria andCopysrcpathIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " is not null");
      return this;
    }

    public Criteria andCopysrcpathIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcpath
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.Copysrcpath
              + " <> ''");
      return this;
    }

    public Criteria andCopysrcpathIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.Copysrcpath
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Copysrcpath
              + " = '')");
      return this;
    }

    public Criteria andCopysrcpathEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " = ", value, "copysrcpath");
      return this;
    }

    public Criteria andCopysrcpathEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcpath);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcpathEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcpathNotEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " <>", value, "copysrcpath");
      return this;
    }

    public Criteria andCopysrcpathNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcpath
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Copysrcpath
              + " <>",
          value,
          "copysrcpath");
      return this;
    }

    public Criteria andCopysrcpathNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcpath);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcpathNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcpathGreaterThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " >", value, "copysrcpath");
      return this;
    }

    public Criteria andCopysrcpathGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcpath);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcpathGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcpathGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " >=", value, "copysrcpath");
      return this;
    }

    public Criteria andCopysrcpathGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcpath);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcpathGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcpathLessThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " <", value, "copysrcpath");
      return this;
    }

    public Criteria andCopysrcpathLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcpath);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcpathLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcpathLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " <=", value, "copysrcpath");
      return this;
    }

    public Criteria andCopysrcpathLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Copysrcpath);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCopysrcpathLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcpathLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcpath + " like", buffer.toString(), "copysrcpath");
      return this;
    }

    public Criteria andCopysrcpathNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcpath + " not like",
          buffer.toString(),
          "copysrcpath");
      return this;
    }

    public Criteria andCopysrcpathIn(List<String> values) {

      if (values.size() == 1) {
        return andCopysrcpathEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " in", values, "copysrcpath");
        return this;
      }
    }

    public Criteria andCopysrcpathNotIn(List<String> values) {
      if (values.size() == 1) {
        return andCopysrcpathNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " not in", values, "copysrcpath");
        return this;
      }
    }

    public Criteria andCopysrcpathIn(String[] values) {

      if (values.length == 1) {
        return andCopysrcpathEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Copysrcpath + " in",
            Arrays.asList(values),
            "copysrcpath");
        return this;
      }
    }

    public Criteria andCopysrcpathNotIn(String[] values) {
      if (values.length == 1) {
        return andCopysrcpathNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Copysrcpath + " not in",
            Arrays.asList(values),
            "copysrcpath");
        return this;
      }
    }

    public Criteria andCopysrcpathIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcpathNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Copysrcpath + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCopysrcpathBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcpath + " between", value1, value2, "copysrcpath");
      return this;
    }

    public Criteria andCopysrcpathNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Copysrcpath + " not between",
          value1,
          value2,
          "copysrcpath");
      return this;
    }

    public Criteria andStatusIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " is null");
      return this;
    }

    public Criteria andStatusIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " is not null");
      return this;
    }

    public Criteria andStatusIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Status
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.Status
              + " <> ''");
      return this;
    }

    public Criteria andStatusIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.Status
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Status
              + " = '')");
      return this;
    }

    public Criteria andStatusEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " = ", value, "status");
      return this;
    }

    public Criteria andStatusEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Status);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.Status
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Status
              + " <>",
          value,
          "status");
      return this;
    }

    public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Status);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " >", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Status);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " >=", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Status);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " <", value, "status");
      return this;
    }

    public Criteria andStatusLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Status);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " <=", value, "status");
      return this;
    }

    public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Status);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " not like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusIn(List<String> values) {

      if (values.size() == 1) {
        return andStatusEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Status + " in", values, "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStatusNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Status + " not in", values, "status");
        return this;
      }
    }

    public Criteria andStatusIn(String[] values) {

      if (values.length == 1) {
        return andStatusEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Status + " in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(String[] values) {
      if (values.length == 1) {
        return andStatusNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Status + " not in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " between", value1, value2, "status");
      return this;
    }

    public Criteria andStatusNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Status + " not between", value1, value2, "status");
      return this;
    }

    public Criteria andRemarksIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " is null");
      return this;
    }

    public Criteria andRemarksIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " is not null");
      return this;
    }

    public Criteria andRemarksIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Remarks
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.Remarks
              + " <> ''");
      return this;
    }

    public Criteria andRemarksIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.Remarks
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Remarks
              + " = '')");
      return this;
    }

    public Criteria andRemarksEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " = ", value, "remarks");
      return this;
    }

    public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Remarks);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " <>", value, "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.Remarks
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Remarks
              + " <>",
          value,
          "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Remarks);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " >", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Remarks);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " >=", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Remarks);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " <", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Remarks);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " <=", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Remarks);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Remarks + " not like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksIn(List<String> values) {

      if (values.size() == 1) {
        return andRemarksEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRemarksNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " not in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(String[] values) {

      if (values.length == 1) {
        return andRemarksEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Remarks + " in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(String[] values) {
      if (values.length == 1) {
        return andRemarksNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Remarks + " not in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Remarks + " between", value1, value2, "remarks");
      return this;
    }

    public Criteria andRemarksNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Remarks + " not between", value1, value2, "remarks");
      return this;
    }

    public Criteria andWorkspaceIdIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " is null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " is not null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceId
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.WorkspaceId
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.WorkspaceId
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(long value) {
      return andWorkspaceIdEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " = ", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(long value) {
      return andWorkspaceIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " <>", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(long value) {
      return andWorkspaceIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.WorkspaceId
              + " <>",
          value,
          "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(long value) {
      return andWorkspaceIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " >", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(long value) {
      return andWorkspaceIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " >=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThan(long value) {
      return andWorkspaceIdLessThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " <", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(long value) {
      return andWorkspaceIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " <=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andWorkspaceIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andWorkspaceIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andWorkspaceIdEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceId + " in",
            Arrays.asList(values),
            "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceId + " not in",
            Arrays.asList(values),
            "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceId + " not between",
          value1,
          value2,
          "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceId + " not between",
          value1,
          value2,
          "workspaceId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " is null");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " is not null");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdEqualTo(long value) {
      return andWorkspaceScmConfigIdEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " = ",
          value,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotEqualTo(long value) {
      return andWorkspaceScmConfigIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdNotEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " <>",
          value,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotEqualToOrIsNull(long value) {
      return andWorkspaceScmConfigIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId
              + " <>",
          value,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThan(long value) {
      return andWorkspaceScmConfigIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdGreaterThan(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " >", value, "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThanOrEqualTo(long value) {
      return andWorkspaceScmConfigIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " >=",
          value,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThan(long value) {
      return andWorkspaceScmConfigIdLessThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdLessThan(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " <", value, "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThanOrEqualTo(long value) {
      return andWorkspaceScmConfigIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " <=",
          value,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceScmConfigIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " in",
            values,
            "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdNotIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceScmConfigIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " not in",
            values,
            "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andWorkspaceScmConfigIdEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " in",
            values,
            "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andWorkspaceScmConfigIdNotEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " not in",
            values,
            "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andWorkspaceScmConfigIdEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " in",
            Arrays.asList(values),
            "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andWorkspaceScmConfigIdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " not in",
            Arrays.asList(values),
            "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " between",
          value1,
          value2,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " between",
          value1,
          value2,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " not between",
          value1,
          value2,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotBetween(
        java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceScmConfigId + " not between",
          value1,
          value2,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andChangeLineCountIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " is null");
      return this;
    }

    public Criteria andChangeLineCountIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " is not null");
      return this;
    }

    public Criteria andChangeLineCountIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.ChangeLineCount
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.ChangeLineCount
              + " <> ''");
      return this;
    }

    public Criteria andChangeLineCountIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.ChangeLineCount
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.ChangeLineCount
              + " = '')");
      return this;
    }

    public Criteria andChangeLineCountEqualTo(long value) {
      return andChangeLineCountEqualTo(Long.valueOf(value));
    }

    public Criteria andChangeLineCountEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " = ", value, "changeLineCount");
      return this;
    }

    public Criteria andChangeLineCountEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.ChangeLineCount);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andChangeLineCountEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andChangeLineCountNotEqualTo(long value) {
      return andChangeLineCountNotEqualTo(Long.valueOf(value));
    }

    public Criteria andChangeLineCountNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " <>", value, "changeLineCount");
      return this;
    }

    public Criteria andChangeLineCountNotEqualToOrIsNull(long value) {
      return andChangeLineCountNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andChangeLineCountNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.ChangeLineCount
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.ChangeLineCount
              + " <>",
          value,
          "changeLineCount");
      return this;
    }

    public Criteria andChangeLineCountNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.ChangeLineCount);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andChangeLineCountNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andChangeLineCountGreaterThan(long value) {
      return andChangeLineCountGreaterThan(Long.valueOf(value));
    }

    public Criteria andChangeLineCountGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " >", value, "changeLineCount");
      return this;
    }

    public Criteria andChangeLineCountGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.ChangeLineCount);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andChangeLineCountGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andChangeLineCountGreaterThanOrEqualTo(long value) {
      return andChangeLineCountGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andChangeLineCountGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " >=", value, "changeLineCount");
      return this;
    }

    public Criteria andChangeLineCountGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.ChangeLineCount);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andChangeLineCountGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andChangeLineCountLessThan(long value) {
      return andChangeLineCountLessThan(Long.valueOf(value));
    }

    public Criteria andChangeLineCountLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " <", value, "changeLineCount");
      return this;
    }

    public Criteria andChangeLineCountLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.ChangeLineCount);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andChangeLineCountLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andChangeLineCountLessThanOrEqualTo(long value) {
      return andChangeLineCountLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andChangeLineCountLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " <=", value, "changeLineCount");
      return this;
    }

    public Criteria andChangeLineCountLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.ChangeLineCount);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andChangeLineCountLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andChangeLineCountIn(long[] values) {
      if (values.length == 1) {
        return andChangeLineCountEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.ChangeLineCount + " in", values, "changeLineCount");
        return this;
      }
    }

    public Criteria andChangeLineCountNotIn(long[] values) {
      if (values.length == 1) {
        return andChangeLineCountNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.ChangeLineCount + " not in", values, "changeLineCount");
        return this;
      }
    }

    public Criteria andChangeLineCountIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andChangeLineCountEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.ChangeLineCount + " in", values, "changeLineCount");
        return this;
      }
    }

    public Criteria andChangeLineCountNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andChangeLineCountNotEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.ChangeLineCount + " not in", values, "changeLineCount");
        return this;
      }
    }

    public Criteria andChangeLineCountIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andChangeLineCountEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.ChangeLineCount + " in",
            Arrays.asList(values),
            "changeLineCount");
        return this;
      }
    }

    public Criteria andChangeLineCountNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andChangeLineCountNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.ChangeLineCount + " not in",
            Arrays.asList(values),
            "changeLineCount");
        return this;
      }
    }

    public Criteria andChangeLineCountIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andChangeLineCountNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.ChangeLineCount + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andChangeLineCountBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.ChangeLineCount + " between",
          value1,
          value2,
          "changeLineCount");
      return this;
    }

    public Criteria andChangeLineCountBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.ChangeLineCount + " between",
          value1,
          value2,
          "changeLineCount");
      return this;
    }

    public Criteria andChangeLineCountNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.ChangeLineCount + " not between",
          value1,
          value2,
          "changeLineCount");
      return this;
    }

    public Criteria andChangeLineCountNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.ChangeLineCount + " not between",
          value1,
          value2,
          "changeLineCount");
      return this;
    }

    public Criteria andLineCountIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " is null");
      return this;
    }

    public Criteria andLineCountIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " is not null");
      return this;
    }

    public Criteria andLineCountIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.LineCount
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.LineCount
              + " <> ''");
      return this;
    }

    public Criteria andLineCountIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.LineCount
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.LineCount
              + " = '')");
      return this;
    }

    public Criteria andLineCountEqualTo(long value) {
      return andLineCountEqualTo(Long.valueOf(value));
    }

    public Criteria andLineCountEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " = ", value, "lineCount");
      return this;
    }

    public Criteria andLineCountEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.LineCount);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLineCountEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andLineCountNotEqualTo(long value) {
      return andLineCountNotEqualTo(Long.valueOf(value));
    }

    public Criteria andLineCountNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " <>", value, "lineCount");
      return this;
    }

    public Criteria andLineCountNotEqualToOrIsNull(long value) {
      return andLineCountNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andLineCountNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.LineCount
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.LineCount
              + " <>",
          value,
          "lineCount");
      return this;
    }

    public Criteria andLineCountNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.LineCount);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLineCountNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andLineCountGreaterThan(long value) {
      return andLineCountGreaterThan(Long.valueOf(value));
    }

    public Criteria andLineCountGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " >", value, "lineCount");
      return this;
    }

    public Criteria andLineCountGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.LineCount);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLineCountGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andLineCountGreaterThanOrEqualTo(long value) {
      return andLineCountGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andLineCountGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " >=", value, "lineCount");
      return this;
    }

    public Criteria andLineCountGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.LineCount);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLineCountGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLineCountLessThan(long value) {
      return andLineCountLessThan(Long.valueOf(value));
    }

    public Criteria andLineCountLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " <", value, "lineCount");
      return this;
    }

    public Criteria andLineCountLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.LineCount);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLineCountLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andLineCountLessThanOrEqualTo(long value) {
      return andLineCountLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andLineCountLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " <=", value, "lineCount");
      return this;
    }

    public Criteria andLineCountLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.LineCount);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLineCountLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLineCountIn(long[] values) {
      if (values.length == 1) {
        return andLineCountEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " in", values, "lineCount");
        return this;
      }
    }

    public Criteria andLineCountNotIn(long[] values) {
      if (values.length == 1) {
        return andLineCountNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " not in", values, "lineCount");
        return this;
      }
    }

    public Criteria andLineCountIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andLineCountEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " in", values, "lineCount");
        return this;
      }
    }

    public Criteria andLineCountNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andLineCountNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " not in", values, "lineCount");
        return this;
      }
    }

    public Criteria andLineCountIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andLineCountEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.LineCount + " in", Arrays.asList(values), "lineCount");
        return this;
      }
    }

    public Criteria andLineCountNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andLineCountNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.LineCount + " not in",
            Arrays.asList(values),
            "lineCount");
        return this;
      }
    }

    public Criteria andLineCountIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLineCountNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.LineCount + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLineCountBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.LineCount + " between", value1, value2, "lineCount");
      return this;
    }

    public Criteria andLineCountBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.LineCount + " between", value1, value2, "lineCount");
      return this;
    }

    public Criteria andLineCountNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.LineCount + " not between", value1, value2, "lineCount");
      return this;
    }

    public Criteria andLineCountNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.LineCount + " not between", value1, value2, "lineCount");
      return this;
    }

    public Criteria andCommentLineCountIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.CommentLineCount + " is null");
      return this;
    }

    public Criteria andCommentLineCountIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.CommentLineCount + " is not null");
      return this;
    }

    public Criteria andCommentLineCountIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.CommentLineCount
              + " <> ''");
      return this;
    }

    public Criteria andCommentLineCountIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.CommentLineCount
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.CommentLineCount
              + " = '')");
      return this;
    }

    public Criteria andCommentLineCountEqualTo(long value) {
      return andCommentLineCountEqualTo(Long.valueOf(value));
    }

    public Criteria andCommentLineCountEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount + " = ", value, "commentLineCount");
      return this;
    }

    public Criteria andCommentLineCountEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.CommentLineCount);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentLineCountEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.CommentLineCount + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentLineCountNotEqualTo(long value) {
      return andCommentLineCountNotEqualTo(Long.valueOf(value));
    }

    public Criteria andCommentLineCountNotEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount + " <>", value, "commentLineCount");
      return this;
    }

    public Criteria andCommentLineCountNotEqualToOrIsNull(long value) {
      return andCommentLineCountNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andCommentLineCountNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.CommentLineCount
              + " <>",
          value,
          "commentLineCount");
      return this;
    }

    public Criteria andCommentLineCountNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.CommentLineCount);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentLineCountNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.CommentLineCount + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentLineCountGreaterThan(long value) {
      return andCommentLineCountGreaterThan(Long.valueOf(value));
    }

    public Criteria andCommentLineCountGreaterThan(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount + " >", value, "commentLineCount");
      return this;
    }

    public Criteria andCommentLineCountGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.CommentLineCount);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentLineCountGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.CommentLineCount + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentLineCountGreaterThanOrEqualTo(long value) {
      return andCommentLineCountGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andCommentLineCountGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount + " >=", value, "commentLineCount");
      return this;
    }

    public Criteria andCommentLineCountGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.CommentLineCount);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentLineCountGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.CommentLineCount + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentLineCountLessThan(long value) {
      return andCommentLineCountLessThan(Long.valueOf(value));
    }

    public Criteria andCommentLineCountLessThan(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount + " <", value, "commentLineCount");
      return this;
    }

    public Criteria andCommentLineCountLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.CommentLineCount);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentLineCountLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.CommentLineCount + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentLineCountLessThanOrEqualTo(long value) {
      return andCommentLineCountLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andCommentLineCountLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount + " <=", value, "commentLineCount");
      return this;
    }

    public Criteria andCommentLineCountLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.CommentLineCount);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentLineCountLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.CommentLineCount + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentLineCountIn(long[] values) {
      if (values.length == 1) {
        return andCommentLineCountEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.CommentLineCount + " in", values, "commentLineCount");
        return this;
      }
    }

    public Criteria andCommentLineCountNotIn(long[] values) {
      if (values.length == 1) {
        return andCommentLineCountNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.CommentLineCount + " not in", values, "commentLineCount");
        return this;
      }
    }

    public Criteria andCommentLineCountIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andCommentLineCountEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.CommentLineCount + " in", values, "commentLineCount");
        return this;
      }
    }

    public Criteria andCommentLineCountNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andCommentLineCountNotEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.CommentLineCount + " not in", values, "commentLineCount");
        return this;
      }
    }

    public Criteria andCommentLineCountIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andCommentLineCountEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.CommentLineCount + " in",
            Arrays.asList(values),
            "commentLineCount");
        return this;
      }
    }

    public Criteria andCommentLineCountNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andCommentLineCountNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.CommentLineCount + " not in",
            Arrays.asList(values),
            "commentLineCount");
        return this;
      }
    }

    public Criteria andCommentLineCountIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.CommentLineCount + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentLineCountNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.CommentLineCount + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentLineCountBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount + " between",
          value1,
          value2,
          "commentLineCount");
      return this;
    }

    public Criteria andCommentLineCountBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount + " between",
          value1,
          value2,
          "commentLineCount");
      return this;
    }

    public Criteria andCommentLineCountNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount + " not between",
          value1,
          value2,
          "commentLineCount");
      return this;
    }

    public Criteria andCommentLineCountNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.CommentLineCount + " not between",
          value1,
          value2,
          "commentLineCount");
      return this;
    }

    public Criteria andBlankLineCountIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " is null");
      return this;
    }

    public Criteria andBlankLineCountIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " is not null");
      return this;
    }

    public Criteria andBlankLineCountIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.BlankLineCount
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.BlankLineCount
              + " <> ''");
      return this;
    }

    public Criteria andBlankLineCountIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.BlankLineCount
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.BlankLineCount
              + " = '')");
      return this;
    }

    public Criteria andBlankLineCountEqualTo(long value) {
      return andBlankLineCountEqualTo(Long.valueOf(value));
    }

    public Criteria andBlankLineCountEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " = ", value, "blankLineCount");
      return this;
    }

    public Criteria andBlankLineCountEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.BlankLineCount);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBlankLineCountEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andBlankLineCountNotEqualTo(long value) {
      return andBlankLineCountNotEqualTo(Long.valueOf(value));
    }

    public Criteria andBlankLineCountNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " <>", value, "blankLineCount");
      return this;
    }

    public Criteria andBlankLineCountNotEqualToOrIsNull(long value) {
      return andBlankLineCountNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andBlankLineCountNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.BlankLineCount
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.BlankLineCount
              + " <>",
          value,
          "blankLineCount");
      return this;
    }

    public Criteria andBlankLineCountNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.BlankLineCount);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBlankLineCountNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andBlankLineCountGreaterThan(long value) {
      return andBlankLineCountGreaterThan(Long.valueOf(value));
    }

    public Criteria andBlankLineCountGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " >", value, "blankLineCount");
      return this;
    }

    public Criteria andBlankLineCountGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.BlankLineCount);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBlankLineCountGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andBlankLineCountGreaterThanOrEqualTo(long value) {
      return andBlankLineCountGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andBlankLineCountGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " >=", value, "blankLineCount");
      return this;
    }

    public Criteria andBlankLineCountGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.BlankLineCount);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBlankLineCountGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andBlankLineCountLessThan(long value) {
      return andBlankLineCountLessThan(Long.valueOf(value));
    }

    public Criteria andBlankLineCountLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " <", value, "blankLineCount");
      return this;
    }

    public Criteria andBlankLineCountLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.BlankLineCount);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBlankLineCountLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andBlankLineCountLessThanOrEqualTo(long value) {
      return andBlankLineCountLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andBlankLineCountLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " <=", value, "blankLineCount");
      return this;
    }

    public Criteria andBlankLineCountLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.BlankLineCount);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBlankLineCountLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andBlankLineCountIn(long[] values) {
      if (values.length == 1) {
        return andBlankLineCountEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.BlankLineCount + " in", values, "blankLineCount");
        return this;
      }
    }

    public Criteria andBlankLineCountNotIn(long[] values) {
      if (values.length == 1) {
        return andBlankLineCountNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.BlankLineCount + " not in", values, "blankLineCount");
        return this;
      }
    }

    public Criteria andBlankLineCountIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andBlankLineCountEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.BlankLineCount + " in", values, "blankLineCount");
        return this;
      }
    }

    public Criteria andBlankLineCountNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andBlankLineCountNotEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.BlankLineCount + " not in", values, "blankLineCount");
        return this;
      }
    }

    public Criteria andBlankLineCountIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andBlankLineCountEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.BlankLineCount + " in",
            Arrays.asList(values),
            "blankLineCount");
        return this;
      }
    }

    public Criteria andBlankLineCountNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andBlankLineCountNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.BlankLineCount + " not in",
            Arrays.asList(values),
            "blankLineCount");
        return this;
      }
    }

    public Criteria andBlankLineCountIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andBlankLineCountNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.BlankLineCount + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andBlankLineCountBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.BlankLineCount + " between",
          value1,
          value2,
          "blankLineCount");
      return this;
    }

    public Criteria andBlankLineCountBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.BlankLineCount + " between",
          value1,
          value2,
          "blankLineCount");
      return this;
    }

    public Criteria andBlankLineCountNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.BlankLineCount + " not between",
          value1,
          value2,
          "blankLineCount");
      return this;
    }

    public Criteria andBlankLineCountNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.BlankLineCount + " not between",
          value1,
          value2,
          "blankLineCount");
      return this;
    }

    public Criteria andFileSizeIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " is null");
      return this;
    }

    public Criteria andFileSizeIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " is not null");
      return this;
    }

    public Criteria andFileSizeIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.FileSize
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.FileSize
              + " <> ''");
      return this;
    }

    public Criteria andFileSizeIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.FileSize
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.FileSize
              + " = '')");
      return this;
    }

    public Criteria andFileSizeEqualTo(long value) {
      return andFileSizeEqualTo(Long.valueOf(value));
    }

    public Criteria andFileSizeEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " = ", value, "fileSize");
      return this;
    }

    public Criteria andFileSizeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.FileSize);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andFileSizeEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andFileSizeNotEqualTo(long value) {
      return andFileSizeNotEqualTo(Long.valueOf(value));
    }

    public Criteria andFileSizeNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " <>", value, "fileSize");
      return this;
    }

    public Criteria andFileSizeNotEqualToOrIsNull(long value) {
      return andFileSizeNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andFileSizeNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.FileSize
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.FileSize
              + " <>",
          value,
          "fileSize");
      return this;
    }

    public Criteria andFileSizeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.FileSize);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andFileSizeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andFileSizeGreaterThan(long value) {
      return andFileSizeGreaterThan(Long.valueOf(value));
    }

    public Criteria andFileSizeGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " >", value, "fileSize");
      return this;
    }

    public Criteria andFileSizeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.FileSize);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andFileSizeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andFileSizeGreaterThanOrEqualTo(long value) {
      return andFileSizeGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andFileSizeGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " >=", value, "fileSize");
      return this;
    }

    public Criteria andFileSizeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.FileSize);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andFileSizeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andFileSizeLessThan(long value) {
      return andFileSizeLessThan(Long.valueOf(value));
    }

    public Criteria andFileSizeLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " <", value, "fileSize");
      return this;
    }

    public Criteria andFileSizeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.FileSize);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andFileSizeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andFileSizeLessThanOrEqualTo(long value) {
      return andFileSizeLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andFileSizeLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " <=", value, "fileSize");
      return this;
    }

    public Criteria andFileSizeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.FileSize);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andFileSizeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andFileSizeIn(long[] values) {
      if (values.length == 1) {
        return andFileSizeEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " in", values, "fileSize");
        return this;
      }
    }

    public Criteria andFileSizeNotIn(long[] values) {
      if (values.length == 1) {
        return andFileSizeNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " not in", values, "fileSize");
        return this;
      }
    }

    public Criteria andFileSizeIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andFileSizeEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " in", values, "fileSize");
        return this;
      }
    }

    public Criteria andFileSizeNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andFileSizeNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " not in", values, "fileSize");
        return this;
      }
    }

    public Criteria andFileSizeIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andFileSizeEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.FileSize + " in", Arrays.asList(values), "fileSize");
        return this;
      }
    }

    public Criteria andFileSizeNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andFileSizeNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.FileSize + " not in", Arrays.asList(values), "fileSize");
        return this;
      }
    }

    public Criteria andFileSizeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andFileSizeNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andFileSizeBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " between", value1, value2, "fileSize");
      return this;
    }

    public Criteria andFileSizeBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.FileSize + " between", value1, value2, "fileSize");
      return this;
    }

    public Criteria andFileSizeNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.FileSize + " not between", value1, value2, "fileSize");
      return this;
    }

    public Criteria andFileSizeNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.FileSize + " not between", value1, value2, "fileSize");
      return this;
    }

    public Criteria andAuthorIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " is null");
      return this;
    }

    public Criteria andAuthorIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " is not null");
      return this;
    }

    public Criteria andAuthorIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Author
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.Author
              + " <> ''");
      return this;
    }

    public Criteria andAuthorIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.Author
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Author
              + " = '')");
      return this;
    }

    public Criteria andAuthorEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " = ", value, "author");
      return this;
    }

    public Criteria andAuthorEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Author);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorNotEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " <>", value, "author");
      return this;
    }

    public Criteria andAuthorNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.Author
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Author
              + " <>",
          value,
          "author");
      return this;
    }

    public Criteria andAuthorNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Author);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorGreaterThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " >", value, "author");
      return this;
    }

    public Criteria andAuthorGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Author);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " >=", value, "author");
      return this;
    }

    public Criteria andAuthorGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Author);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorLessThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " <", value, "author");
      return this;
    }

    public Criteria andAuthorLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Author);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " <=", value, "author");
      return this;
    }

    public Criteria andAuthorLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Author);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " like", buffer.toString(), "author");
      return this;
    }

    public Criteria andAuthorNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " not like", buffer.toString(), "author");
      return this;
    }

    public Criteria andAuthorIn(List<String> values) {

      if (values.size() == 1) {
        return andAuthorEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Author + " in", values, "author");
        return this;
      }
    }

    public Criteria andAuthorNotIn(List<String> values) {
      if (values.size() == 1) {
        return andAuthorNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Author + " not in", values, "author");
        return this;
      }
    }

    public Criteria andAuthorIn(String[] values) {

      if (values.length == 1) {
        return andAuthorEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Author + " in", Arrays.asList(values), "author");
        return this;
      }
    }

    public Criteria andAuthorNotIn(String[] values) {
      if (values.length == 1) {
        return andAuthorNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Author + " not in", Arrays.asList(values), "author");
        return this;
      }
    }

    public Criteria andAuthorIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " between", value1, value2, "author");
      return this;
    }

    public Criteria andAuthorNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Author + " not between", value1, value2, "author");
      return this;
    }

    public Criteria andRevisionTimeIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.RevisionTime + " is null");
      return this;
    }

    public Criteria andRevisionTimeIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.RevisionTime + " is not null");
      return this;
    }

    public Criteria andRevisionTimeIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.RevisionTime
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.RevisionTime
              + " <> ''");
      return this;
    }

    public Criteria andRevisionTimeIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.RevisionTime
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.RevisionTime
              + " = '')");
      return this;
    }

    public Criteria andRevisionTimeEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceScmChangePathLogDAO.RevisionTime + " = ", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.RevisionTime);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.RevisionTime + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeNotEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceScmChangePathLogDAO.RevisionTime + " <>", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeNotEqualToOrIsNull(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceScmChangePathLogDAO.RevisionTime
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.RevisionTime
              + " <>",
          value,
          "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.RevisionTime);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.RevisionTime + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeGreaterThan(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceScmChangePathLogDAO.RevisionTime + " >", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.RevisionTime);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.RevisionTime + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeGreaterThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceScmChangePathLogDAO.RevisionTime + " >=", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.RevisionTime);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.RevisionTime + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeLessThan(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceScmChangePathLogDAO.RevisionTime + " <", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.RevisionTime);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.RevisionTime + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeLessThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceScmChangePathLogDAO.RevisionTime + " <=", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.RevisionTime);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.RevisionTime + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeIn(List<java.util.Date> values) {

      if (values.size() == 1) {
        return andRevisionTimeEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(
            IWorkspaceScmChangePathLogDAO.RevisionTime + " in", values, "revisionTime");
        return this;
      }
    }

    public Criteria andRevisionTimeNotIn(List<java.util.Date> values) {
      if (values.size() == 1) {
        return andRevisionTimeNotEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(
            IWorkspaceScmChangePathLogDAO.RevisionTime + " not in", values, "revisionTime");
        return this;
      }
    }

    public Criteria andRevisionTimeIn(java.util.Date[] values) {

      if (values.length == 1) {
        return andRevisionTimeEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IWorkspaceScmChangePathLogDAO.RevisionTime + " in",
            Arrays.asList(values),
            "revisionTime");
        return this;
      }
    }

    public Criteria andRevisionTimeNotIn(java.util.Date[] values) {
      if (values.length == 1) {
        return andRevisionTimeNotEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IWorkspaceScmChangePathLogDAO.RevisionTime + " not in",
            Arrays.asList(values),
            "revisionTime");
        return this;
      }
    }

    public Criteria andRevisionTimeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.RevisionTime + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.RevisionTime + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(
          IWorkspaceScmChangePathLogDAO.RevisionTime + " between", value1, value2, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeNotBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(
          IWorkspaceScmChangePathLogDAO.RevisionTime + " not between",
          value1,
          value2,
          "revisionTime");
      return this;
    }

    public Criteria andRevisionIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " is null");
      return this;
    }

    public Criteria andRevisionIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " is not null");
      return this;
    }

    public Criteria andRevisionIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Revision
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.Revision
              + " <> ''");
      return this;
    }

    public Criteria andRevisionIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.Revision
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Revision
              + " = '')");
      return this;
    }

    public Criteria andRevisionEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " = ", value, "revision");
      return this;
    }

    public Criteria andRevisionEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Revision);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionNotEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " <>", value, "revision");
      return this;
    }

    public Criteria andRevisionNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.Revision
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.Revision
              + " <>",
          value,
          "revision");
      return this;
    }

    public Criteria andRevisionNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Revision);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionGreaterThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " >", value, "revision");
      return this;
    }

    public Criteria andRevisionGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Revision);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " >=", value, "revision");
      return this;
    }

    public Criteria andRevisionGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Revision);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionLessThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " <", value, "revision");
      return this;
    }

    public Criteria andRevisionLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Revision);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " <=", value, "revision");
      return this;
    }

    public Criteria andRevisionLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.Revision);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " like", buffer.toString(), "revision");
      return this;
    }

    public Criteria andRevisionNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Revision + " not like", buffer.toString(), "revision");
      return this;
    }

    public Criteria andRevisionIn(List<String> values) {

      if (values.size() == 1) {
        return andRevisionEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " in", values, "revision");
        return this;
      }
    }

    public Criteria andRevisionNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRevisionNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " not in", values, "revision");
        return this;
      }
    }

    public Criteria andRevisionIn(String[] values) {

      if (values.length == 1) {
        return andRevisionEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Revision + " in", Arrays.asList(values), "revision");
        return this;
      }
    }

    public Criteria andRevisionNotIn(String[] values) {
      if (values.length == 1) {
        return andRevisionNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.Revision + " not in", Arrays.asList(values), "revision");
        return this;
      }
    }

    public Criteria andRevisionIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmChangePathLogDAO.Revision + " between", value1, value2, "revision");
      return this;
    }

    public Criteria andRevisionNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.Revision + " not between", value1, value2, "revision");
      return this;
    }

    public Criteria andTotalLinesIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " is null");
      return this;
    }

    public Criteria andTotalLinesIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " is not null");
      return this;
    }

    public Criteria andTotalLinesIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalLines
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.TotalLines
              + " <> ''");
      return this;
    }

    public Criteria andTotalLinesIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.TotalLines
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.TotalLines
              + " = '')");
      return this;
    }

    public Criteria andTotalLinesEqualTo(long value) {
      return andTotalLinesEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalLinesEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " = ", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalLines);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesNotEqualTo(long value) {
      return andTotalLinesNotEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalLinesNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " <>", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesNotEqualToOrIsNull(long value) {
      return andTotalLinesNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andTotalLinesNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalLines
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.TotalLines
              + " <>",
          value,
          "totalLines");
      return this;
    }

    public Criteria andTotalLinesNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalLines);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesGreaterThan(long value) {
      return andTotalLinesGreaterThan(Long.valueOf(value));
    }

    public Criteria andTotalLinesGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " >", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalLines);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesGreaterThanOrEqualTo(long value) {
      return andTotalLinesGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalLinesGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " >=", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalLines);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesLessThan(long value) {
      return andTotalLinesLessThan(Long.valueOf(value));
    }

    public Criteria andTotalLinesLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " <", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalLines);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesLessThanOrEqualTo(long value) {
      return andTotalLinesLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalLinesLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " <=", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalLines);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesIn(long[] values) {
      if (values.length == 1) {
        return andTotalLinesEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " in", values, "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesNotIn(long[] values) {
      if (values.length == 1) {
        return andTotalLinesNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " not in", values, "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andTotalLinesEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " in", values, "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andTotalLinesNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " not in", values, "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andTotalLinesEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.TotalLines + " in", Arrays.asList(values), "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andTotalLinesNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.TotalLines + " not in",
            Arrays.asList(values),
            "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalLines + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalLines + " between", value1, value2, "totalLines");
      return this;
    }

    public Criteria andTotalLinesBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalLines + " between", value1, value2, "totalLines");
      return this;
    }

    public Criteria andTotalLinesNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalLines + " not between", value1, value2, "totalLines");
      return this;
    }

    public Criteria andTotalLinesNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalLines + " not between", value1, value2, "totalLines");
      return this;
    }

    public Criteria andTotalSizeIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " is null");
      return this;
    }

    public Criteria andTotalSizeIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " is not null");
      return this;
    }

    public Criteria andTotalSizeIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalSize
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.TotalSize
              + " <> ''");
      return this;
    }

    public Criteria andTotalSizeIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.TotalSize
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.TotalSize
              + " = '')");
      return this;
    }

    public Criteria andTotalSizeEqualTo(long value) {
      return andTotalSizeEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalSizeEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " = ", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalSize);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeNotEqualTo(long value) {
      return andTotalSizeNotEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalSizeNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " <>", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeNotEqualToOrIsNull(long value) {
      return andTotalSizeNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andTotalSizeNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalSize
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.TotalSize
              + " <>",
          value,
          "totalSize");
      return this;
    }

    public Criteria andTotalSizeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalSize);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeGreaterThan(long value) {
      return andTotalSizeGreaterThan(Long.valueOf(value));
    }

    public Criteria andTotalSizeGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " >", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalSize);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeGreaterThanOrEqualTo(long value) {
      return andTotalSizeGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalSizeGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " >=", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalSize);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeLessThan(long value) {
      return andTotalSizeLessThan(Long.valueOf(value));
    }

    public Criteria andTotalSizeLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " <", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalSize);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeLessThanOrEqualTo(long value) {
      return andTotalSizeLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalSizeLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " <=", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.TotalSize);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeIn(long[] values) {
      if (values.length == 1) {
        return andTotalSizeEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " in", values, "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeNotIn(long[] values) {
      if (values.length == 1) {
        return andTotalSizeNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " not in", values, "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andTotalSizeEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " in", values, "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andTotalSizeNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " not in", values, "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andTotalSizeEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.TotalSize + " in", Arrays.asList(values), "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andTotalSizeNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.TotalSize + " not in",
            Arrays.asList(values),
            "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.TotalSize + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalSize + " between", value1, value2, "totalSize");
      return this;
    }

    public Criteria andTotalSizeBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalSize + " between", value1, value2, "totalSize");
      return this;
    }

    public Criteria andTotalSizeNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalSize + " not between", value1, value2, "totalSize");
      return this;
    }

    public Criteria andTotalSizeNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.TotalSize + " not between", value1, value2, "totalSize");
      return this;
    }

    public Criteria andWorkspaceNameIsNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " is null");
      return this;
    }

    public Criteria andWorkspaceNameIsNotNull() {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " is not null");
      return this;
    }

    public Criteria andWorkspaceNameIsNotEmpty() {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceName
              + " is not null AND "
              + IWorkspaceScmChangePathLogDAO.WorkspaceName
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceNameIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmChangePathLogDAO.WorkspaceName
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.WorkspaceName
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceNameEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " = ", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceName);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameNotEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " <>", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceName
              + " is null OR "
              + IWorkspaceScmChangePathLogDAO.WorkspaceName
              + " <>",
          value,
          "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceName);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameGreaterThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " >", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceName);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " >=", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceName);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameLessThan(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " <", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceName);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " <=", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmChangePathLogDAO.WorkspaceName);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceName + " like",
          buffer.toString(),
          "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceName + " not like",
          buffer.toString(),
          "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameIn(List<String> values) {

      if (values.size() == 1) {
        return andWorkspaceNameEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " in", values, "workspaceName");
        return this;
      }
    }

    public Criteria andWorkspaceNameNotIn(List<String> values) {
      if (values.size() == 1) {
        return andWorkspaceNameNotEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceName + " not in", values, "workspaceName");
        return this;
      }
    }

    public Criteria andWorkspaceNameIn(String[] values) {

      if (values.length == 1) {
        return andWorkspaceNameEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceName + " in",
            Arrays.asList(values),
            "workspaceName");
        return this;
      }
    }

    public Criteria andWorkspaceNameNotIn(String[] values) {
      if (values.length == 1) {
        return andWorkspaceNameNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmChangePathLogDAO.WorkspaceName + " not in",
            Arrays.asList(values),
            "workspaceName");
        return this;
      }
    }

    public Criteria andWorkspaceNameIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmChangePathLogDAO.WorkspaceName + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceName + " between",
          value1,
          value2,
          "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceScmChangePathLogDAO.WorkspaceName + " not between",
          value1,
          value2,
          "workspaceName");
      return this;
    }
  }
}
